Introduction

In programming, data can behave in two important ways: it can be mutable or immutable.

Mutable data can be changed after it is created. Immutable data cannot be changed after it is created.

This concept is very important in memory management, value and reference types, functional programming, object-oriented programming, and data safety.

Easy Real-Life Example

Whiteboard:
Original text: "Math Class"
Changed text:  "Programming Class"

Same whiteboard, changed content.

This is similar to mutable data. The same object can be changed.

Certificate:
Original certificate: "Aman scored 80"
New certificate:      "Aman scored 85"

Original certificate is not changed.
A new certificate is created.

This is similar to immutable data. Instead of changing the original object, a new object is created.

What is Mutable Data?

Mutable data is data that can be changed after it is created.

If an object is mutable, we can update its contents without creating a completely new object.

Mutable Data Example

/*
This example shows mutable data behavior.
A list can be changed after creation.
*/

ENTRY POINT
    DECLARE marks AS LIST = [70, 80, 90]

    ADD 95 TO marks

    DISPLAY marks
END ENTRY POINT

Expected Output

[70, 80, 90, 95]

Here, the list marks is modified by adding a new value. The same list changes.

What is Immutable Data?

Immutable data is data that cannot be changed after it is created.

If we want a different value, the program creates a new value or object instead of modifying the original one.

Immutable Data Example

/*
This example shows immutable data behavior.
Changing text creates a new text value.
*/

ENTRY POINT
    DECLARE message AS TEXT = "Hello"

    SET message = message + " World"

    DISPLAY message
END ENTRY POINT

Expected Output

Hello World

Although it looks like the text was changed, many programming languages create a new text value instead of modifying the original text directly.

Mutable vs Immutable Data

Common Mutable Data Examples

Exact rules depend on the programming language, but common mutable data types often include:

Example: Mutable List

ENTRY POINT
    DECLARE students AS LIST = ["Aman", "Riya"]

    ADD "Sohan" TO students

    DISPLAY students
END ENTRY POINT

Expected Output

["Aman", "Riya", "Sohan"]

The list is changed after creation, so it behaves like mutable data.

Common Immutable Data Examples

Exact rules depend on the programming language, but common immutable data types often include:

Example: Immutable Number

ENTRY POINT
    DECLARE x AS INTEGER = 10

    SET x = x + 5

    DISPLAY x
END ENTRY POINT

Expected Output

15

Conceptually, the value 10 is not changed into 15. Instead, the variable x is updated to refer to or hold a new value.

Memory Idea Behind Mutability

Mutability is closely related to how data behaves in memory.

Mutable Memory Idea

list1 → [10, 20, 30]

ADD 40 TO list1

list1 → [10, 20, 30, 40]

Same list object, changed content.

Immutable Memory Idea

text → "Hello"

text = text + " World"

Old value: "Hello"
New value: "Hello World"

The original text value is not modified directly.

Mutable Data and Shared References

Mutable data can cause unexpected results when two variables refer to the same object.

Example: Shared Mutable List

/*
Both variables refer to the same list.
Changing one affects the other.
*/

ENTRY POINT
    DECLARE list1 AS LIST = [1, 2, 3]
    SET list2 = list1

    ADD 4 TO list2

    DISPLAY list1
    DISPLAY list2
END ENTRY POINT

Expected Output

[1, 2, 3, 4]
[1, 2, 3, 4]

Since list1 and list2 refer to the same list, modifying the list through list2 also changes what list1 sees.

Immutable Data and Safe Copies

Immutable data is safer to share because it cannot be changed in place.

Example: Immutable Text

/*
Both variables first refer to the same text value.
Reassigning one does not change the original value.
*/

ENTRY POINT
    DECLARE text1 AS TEXT = "Hello"
    SET text2 = text1

    SET text2 = text2 + " World"

    DISPLAY text1
    DISPLAY text2
END ENTRY POINT

Expected Output

Hello
Hello World

text1 remains unchanged because the original text value is not modified directly.

Mutable Object Example

/*
Object properties can often be changed after creation.
This is mutable behavior.
*/

CLASS Student
    PROPERTY name
    PROPERTY marks
END CLASS

ENTRY POINT
    CREATE student AS Student
    SET student.name = "Aman"
    SET student.marks = 80

    SET student.marks = 90

    DISPLAY student.name
    DISPLAY student.marks
END ENTRY POINT

Expected Output

Aman
90

The student object is changed after creation because its marks property is updated.

Immutable Object Example

Some objects are designed so that their values cannot be changed after creation.

/*
Immutable-style student record.
Instead of changing existing data,
create a new record with updated value.
*/

RECORD StudentRecord
    FIELD name
    FIELD marks
END RECORD

ENTRY POINT
    CREATE oldRecord AS StudentRecord("Aman", 80)

    CREATE newRecord AS StudentRecord("Aman", 90)

    DISPLAY oldRecord
    DISPLAY newRecord
END ENTRY POINT

Expected Output

StudentRecord("Aman", 80)
StudentRecord("Aman", 90)

The old record remains unchanged. A new record is created for the updated marks.

Reassignment vs Mutation

Beginners often confuse reassignment with mutation.

Reassignment Example

x = 10
x = 20

Here, the variable x is reassigned.

Mutation Example

numbers = [1, 2, 3]
ADD 4 TO numbers

Here, the list object is mutated.

Function Argument Example with Mutable Data

Mutable data can be changed inside a function if the function receives a reference to the same object.

/*
The function modifies the original list.
*/

FUNCTION addBonusMark(marks)
    ADD 5 TO marks
END FUNCTION

ENTRY POINT
    DECLARE studentMarks AS LIST = [70, 80, 90]

    CALL addBonusMark(studentMarks)

    DISPLAY studentMarks
END ENTRY POINT

Expected Output

[70, 80, 90, 5]

The original list is changed because the function modifies the same mutable object.

Function Argument Example with Immutable Data

Immutable data usually does not change outside the function when modified inside the function.

/*
The function changes its local value,
but the original value remains unchanged.
*/

FUNCTION increase(number)
    SET number = number + 1
    DISPLAY "Inside function: " + number
END FUNCTION

ENTRY POINT
    DECLARE count AS INTEGER = 10

    CALL increase(count)

    DISPLAY "Outside function: " + count
END ENTRY POINT

Expected Output

Inside function: 11
Outside function: 10

The original count remains unchanged because the function works with its own local value.

Why Immutable Data is Useful

Immutable data is useful because it makes programs more predictable.

Why Mutable Data is Useful

Mutable data is useful when we need frequent updates and flexible changes.

Real-World Example: Shopping Cart

A shopping cart is usually mutable because users can add, remove, or update items.

cart = []

ADD "Keyboard" TO cart
ADD "Mouse" TO cart
REMOVE "Mouse" FROM cart

DISPLAY cart

Expected Output

["Keyboard"]

The cart changes over time, so mutable data is suitable here.

Real-World Example: Transaction Record

A financial transaction record should often be treated as immutable because changing old transaction data can be dangerous.

transaction1 = {
    "id": 101,
    "amount": 500,
    "status": "Completed"
}

If correction is needed:
Create transaction2 or adjustment record
Do not silently modify transaction1

Immutable-style data helps preserve trust, history, and auditability.

Mutable and Immutable Data in Functional Programming

Functional programming often prefers immutable data.

Instead of changing the original data, functional programming encourages creating new transformed data.

Functional Immutable Style

/*
Original list remains unchanged.
A new list is created.
*/

ENTRY POINT
    DECLARE oldMarks AS LIST = [70, 80, 90]

    DECLARE updatedMarks AS LIST = MAP each mark IN oldMarks:
        RETURN mark + 5

    DISPLAY oldMarks
    DISPLAY updatedMarks
END ENTRY POINT

Expected Output

[70, 80, 90]
[75, 85, 95]

This approach avoids changing the original data.

Copying Mutable Data

When working with mutable data, copying must be handled carefully.

list1 = [1, 2, 3]
list2 = list1

ADD 4 TO list2

DISPLAY list1

Output

[1, 2, 3, 4]

This happens because list2 may refer to the same list as list1.

Safer Copy Idea

list1 = [1, 2, 3]
list2 = COPY OF list1

ADD 4 TO list2

DISPLAY list1
DISPLAY list2

Output

[1, 2, 3]
[1, 2, 3, 4]

Creating a real copy prevents accidental modification of the original list.

Shallow Copy and Deep Copy

With mutable nested data, copying can be more complex.

Students should understand this concept before working with nested lists, dictionaries, objects, and complex data structures.

Mutable Data, Immutable Data, and Value/Reference Types

Mutable and immutable data are related to value and reference types, but they are not exactly the same concept.

Performance Considerations

Mutable and immutable data can affect performance differently.

Common Bugs Caused by Mutable Data

Mutable data is powerful, but it can create hidden side effects.

FUNCTION addStudent(students)
    ADD "New Student" TO students
END FUNCTION

ENTRY POINT
    classList = ["Aman", "Riya"]

    CALL addStudent(classList)

    DISPLAY classList
END ENTRY POINT

Output

["Aman", "Riya", "New Student"]

If the caller did not expect the original list to change, this becomes a bug.

How to Avoid Mutable Data Bugs

Advantages of Mutable Data

Advantages of Immutable Data

Limitations of Mutable Data

Limitations of Immutable Data

When to Use Mutable Data

When to Use Immutable Data

Common Beginner Mistakes

Best Practices

Prerequisites Before Learning This Topic

Students should understand the following topics before learning mutable and immutable data deeply:

Trace Table Example: Mutable Data

list1 = [1, 2]
list2 = list1
ADD 3 TO list2

Trace Table Example: Immutable Data

text1 = "Hi"
text2 = text1
text2 = text2 + " There"

Practice Activity: Identify Mutable or Immutable

Identify whether the behavior is mutable or immutable.

1. A list allows adding a new element after creation.
2. A string does not allow changing one character directly.
3. A dictionary allows updating the value of a key.
4. A number variable is reassigned from 10 to 20.
5. A tuple-like fixed collection cannot be changed after creation.
6. A student object allows updating the marks property.

Sample Answers

1. Mutable
2. Immutable
3. Mutable
4. Immutable-style value reassignment
5. Immutable
6. Mutable

Mini Quiz

Interview Questions on Mutable and Immutable Data

Quick Summary