Home > Object Oriented Programming > Object Oriented Programming > Mutability Vs Immutability

Understanding Mutability & Immutability in Programming

In the realm of software development, especially when dealing with object-oriented or functional programming paradigms, the concepts of mutability and immutability play a pivotal role. They influence not just how data is handled, but also the overall robustness, efficiency, and clarity of the code.

Mutability and immutability are key concepts in both object-oriented and functional programming. This refers to the ability of an object to change its internal state.

Mutability & Immutability, What’s the Difference?

Mutable Objects: The Malleable Entities

Mutable objects, as the name suggests, are flexible. They can be altered or 'mutated' after they've been initialized. This means that their internal state or data can change over time, often in response to program actions or operations.

For example, consider a list in Python. You can add, remove, or modify its elements after its creation, making it a classic example of a mutable object.

Advantages:

Flexibility: Mutable objects can be adjusted on-the-fly, making them adaptable to dynamic data or changing requirements.
In-Place Modifications: Since you can change the content directly, there's no need to create a new object every time a change is needed. This can be memory-efficient for large data structures.

Drawbacks:

Thread Safety: Mutable objects can be tricky in multi-threaded environments. Simultaneous modifications by different threads can lead to unpredictable behaviors or data corruption.
Predictability: Continuous changes to an object can make the flow of data harder to trace and debug.

Immutable Objects: The Constants in Chaos

Contrastingly, immutable objects are set in stone. Once they're created, their state remains unchanged. Any operation that seems to alter them actually creates a new object with the desired changes, leaving the original untouched.

Take the example of strings in many programming languages. When you "modify" a string, you're often creating a new one while the original remains unaltered.

Advantages:

Thread Safety: Since the state of an immutable object never changes, there's no risk of data corruption from simultaneous modifications. This makes them inherently safe in concurrent or parallel processing scenarios.
Predictability & Readability: With no unexpected changes, the behavior of immutable objects is easier to understand, making the code more readable.
Security: Immutable objects can't be tampered with, ensuring data integrity.

Drawbacks:

Memory Overhead: Every "modification" leads to a new object, which can be memory-intensive for large data structures or frequent changes.

Getting It?

Simply put, a mutable object can have its internal state changed aka 'mutated', whereas an immutable object cannot be changed once created.

Strings are an example of objects that are immutable. They are frequently used in programming to improve readability and runtime efficiency. These objects are also advantageous because they are by nature, thread-safe, easier to understand and reason about, and provide greater security in comparison to mutable objects.

Ultimately, whether an object is mutable or immutable can greatly influence how it is used and the overall performance of your code.

So, should I use mutability or immutability? Let's dig a little deeper and see what situations are preferable for both.

Mutability & Immutability, What’s the Difference?

Build your intuition. Is this statement true or false?

True or False: You can change an immutable object after it has been created.

Press true if you believe the statement is correct, or false otherwise.

Mutability, When and Why Should It?

Various factors can influence whether mutable or immutable objects are used in programming. Consider the following reasons why programmers may prefer mutability:

Speed & Efficiency: Some developers may choose mutable objects because they are faster and more efficient. However, on the downside this may result in more time spent fixing bugs in the long run.
Convenience: Mutable objects often require less code and fewer variables in the short run.
Necessity: In some cases, using mutation is unavoidable, particularly when dealing with user input or UI modifications.

Overall, mutable objects may be more appropriate in situations where speed is a top priority, such as game development or real-time stock market software. In most cases, the risks of mutation outweigh the benefits. However, for small and simple programs, the risks may not be significant enough to warrant consideration of immutability.

Immutability, When and Why Should It?

Immutable objects offer a number of advantages over their mutable counterparts. Let's explore some of the reasons why programmers might prefer immutability:

Readability: Since variables remain constant, code is easier to understand. Extensive commenting is no longer required.
Speed & Efficiency: We spoke earlier about the advantage of mutability in the short-run, however using immutability improves speed and efficiency in the long-run. While writing immutable code requires more effort, it is easier to manage and update. Have you ever heard the expression "short term pain, long term gain?" That is immutability in a nutshell.
Traceability: This is made easier because it is possible to identify how and where data changes in the code, as well as which parts of the application need to be reloaded with each change.
Safety & Validity: Once an immutable object's state is verified, its safety and validity are guaranteed because no background process can change it without the developer's knowledge.
Caching: The immutability of the values of immutable objects makes them ideal for caching and simplifies testing and debugging.

Now that we've established that, let's look at mutability and immutability in the context of a few differing programming languages.

Are you sure you're getting this? Is this statement true or false?

True or False: Using mutability improves the readability of you code.

Press true if you believe the statement is correct, or false otherwise.

Python

Mutable Data Types

Some examples of mutable data types in Python are as follows:

List
Dict
Set
Byte Array
User-defined classes.

Mutable Example

Let's say we want to create a list of our favorite movies.

PYTHON

1fav_movies = ["American Gangster", "Bohemian Rhapsody", "Shutter Island", "The Intouchables"]

Now, let's say you go to the movies to see the new avatar movie and decide it's your new favorite. We can easily add this to our list by putting it at the first index.

PYTHON

1fav_movies[0] = "Avatar: The Way of Water"

When we call our list, we get the following result:

PYTHON

1fav_movies
2# ['Avatar: The Way of Water','Bohemian Rhapsody','Shutter Island', 'The Intouchables']

Immutable Data Types

Some examples of immutable data types in Python are as follows:

Str
Int
Float
Complex
Tuple
Frozen Set
Boolean.

Immutability libraries such as dataclasses and namedtuples can be used to make mutable classes immutable.

Immutable Example

Let's say we want to define a string that contains our now favorite movie Avatar.

PYTHON

1new_fav = "Avatar"

But then you realize you forgot to specify it was "Avatar 2"

PYTHON

1new_fav[7] = "2"

Because a string is immutable, the result is a TypeError.

xxxxxxxxxx
 
# Mutable Data Types Example
​
# Creating a list of favorite movies
fav_movies = ["American Gangster", "Bohemian Rhapsody", "Shutter Island", "The Intouchables"]
​
# Modifying the first movie in the list
fav_movies[0] = "Avatar: The Way of Water"
​
# Displaying the modified list
print(fav_movies)  # ['Avatar: The Way of Water','Bohemian Rhapsody','Shutter Island', 'The Intouchables']
​
# Immutable Data Types Example
​
# Creating a string for the favorite movie
new_fav = "Avatar"
​
# Trying to modify the string (will result in a TypeError)
try:
    new_fav[7] = "2"
except TypeError as e:
    print(f"Error: {e}")
​
if __name__ == "__main__":
    pass

Java

Mutable Data Types

Some examples of mutable data types in Java are as follows:

Array
ArrayList
HashMap
HashSet
LinkedList
TreeMap
TreeSet
VectorStringBuilder
java.util.Date
java.util.Calendar.

Mutable Example

The following is an example of mutability in Java.

JAVASCRIPT

1class MutableEx {
2   private int x;
3   
4   public MmutableEx(int, x) {
5   	this.x = x;
6   }
7   public void setX(int x) {
8   	this.x = x;
9   }
10   ...
11}

The class 'MutableEx' is mutable because we can change the value of the attribute x using the setter we created.

Immutable Data Types

Some examples of immutable data types in Java are as follows:

String
Integer
Long
Float
Double
Short
Byte
Character
Boolean
java.math.BigInteger
java.math.BigDecimal
java.time.* classes (such as LocalDate, LocalTime, LocalDateTime, and Instant).

It's worth noting that some mutable classes can be made immutable by using specific methods or constructors, or by using immutability libraries such as Guava and Apache Commons Lang.

Immutable Example

The following is an example of immutability in Java.

JAVASCRIPT

1class ImmutableEx {
2   private int x;
3   
4   public ImmutableEx(int, x) {
5   	this.x = x;
6   }
7   public int getX() {
8   	return.this.x;
9   }
10}

The class 'ImmutableEx' is immutable because if we create an object from this class we cannot change the value of the attribute x of this object.

xxxxxxxxxx
}
 
import java.util.*;
​
public class Main {
​
    // Mutable Example class
    static class MutableEx {
        private int x;
       
        public MutableEx(int x) {
            this.x = x;
        }
       
        public void setX(int x) {
            this.x = x;
        }
        
        public int getX() {
            return this.x;
        }
    }
​
    // Immutable Example class
    static class ImmutableEx {
        private final int x;
       
        public ImmutableEx(int x) {
            this.x = x;
        }
       

Build your intuition. Is this statement true or false?

True or False: In both Java and Python, strings are considered an immutable data type.

Press true if you believe the statement is correct, or false otherwise.

JavaScript

Mutable Data Types

In JavaScript, some of the mutable data types include:

Object
Array

Mutable Example

Let's assume we want to create an array of our favorite movies.

JAVASCRIPT

1let favMovies = ["American Gangster", "Bohemian Rhapsody", "Shutter Island", "The Intouchables"];

Now, let's imagine you've just watched the new Avatar movie and you've decided it's your new favorite. We can easily add this to our list by placing it at the first index.

JAVASCRIPT

1favMovies[0] = "Avatar: The Way of Water";

When we log our array, we get the following result:

JAVASCRIPT

1console.log(favMovies);
2// ['Avatar: The Way of Water','Bohemian Rhapsody','Shutter Island', 'The Intouchables']

Immutable Data Types

In JavaScript, some examples of immutable data types include:

String
Number
Boolean
undefined
null

While JavaScript doesn't have in-built immutability libraries like Python, there are third-party libraries such as Immutable.js that can be used to achieve immutability.

Immutable Example

Let's say we want to define a string that represents our new favorite movie, Avatar.

JAVASCRIPT

1let newFav = "Avatar";

But then you realize you forgot to specify it was "Avatar 2". Trying to change a character in a string will lead to an error in strict mode.

JAVASCRIPT

1newFav[6] = "2";

Because a string is immutable in JavaScript, attempting to modify it this way won't have any effect and will throw an error in strict mode.

xxxxxxxxxx
 
// Mutable example
let favMovies = ["American Gangster", "Bohemian Rhapsody", "Shutter Island", "The Intouchables"];
​
// Assume you've just watched the new Avatar movie and decided it's your new favorite.
favMovies[0] = "Avatar: The Way of Water";
​
console.log("Updated Favorite Movies List:");
console.log(favMovies);
// ['Avatar: The Way of Water','Bohemian Rhapsody','Shutter Island', 'The Intouchables']
​
console.log("\n"); // For spacing
​
// Immutable example
let newFav = "Avatar";
​
// Uncommenting the line below won't have any effect and will throw an error in strict mode
// newFav[6] = "2"; 
​
console.log("Favorite Movie:");
console.log(newFav);

C++

Mutable Data Types

In C++, mutable container types include:

Vector
Map
Set
Deque
Array
List

Mutable Example

Let's say we wish to create a vector of our favorite games.

TEXT/X-C++SRC

1#include <iostream>
2#include <vector>
3
4int main() {
5    std::vector<std::string> favGames = {"Halo", "Age of Empires", "The Witcher", "Civilization"};
6
7    // Now, let's assume you've just played the new game "Cyberpunk" and you've decided it's your new favorite. 
8    // We can easily add this to our list.
9    favGames[0] = "Cyberpunk 2077";
10
11    // Print the updated list
12    for(const auto& game : favGames) {
13        std::cout << game << std::endl;
14    }
15
16    return 0;
17}

Immutable Data Types

In C++, the concept of immutability is not tied to specific data types but rather achieved using const qualifier.

Immutable Example

Let's say we have a string to store the title of a book you just read, Dune.

TEXT/X-C++SRC

1#include <iostream>
2#include <string>
3
4int main() {
5    const std::string favBook = "Dune";
6
7    // Now, if you try to change the book title to "Dune 2", you'll encounter a compilation error.
8    // favBook = "Dune 2"; // This line will cause a compile-time error
9
10    std::cout << favBook << std::endl;
11
12    return 0;
13}

Because the string is declared as const, it becomes immutable and attempting to modify its value will result in a compilation error.

xxxxxxxxxx
 
#include <iostream>
#include <vector>
#include <string>
​
int main() {
    // Mutable example
    std::vector<std::string> favGames = {"Halo", "Age of Empires", "The Witcher", "Civilization"};
​
    // Assume you've just played the new game "Cyberpunk" and decided it's your new favorite. 
    favGames[0] = "Cyberpunk 2077";
​
    std::cout << "Updated Favorite Games List:" << std::endl;
    for(const auto& game : favGames) {
        std::cout << game << std::endl;
    }
​
    std::cout << std::endl; // For spacing
​
    // Immutable example
    const std::string favBook = "Dune";
​
    // Uncommenting the line below will cause a compile-time error since the string is immutable
    // favBook = "Dune 2"; 
​
    std::cout << "Favorite Book: " << favBook << std::endl;
​
    return 0;
}

Conclusion

In this tutorial, we defined the distinction between mutability and immutability in the contexts of several programming languages.

To Mutate or Not to Mutate?

The choice between mutable and immutable objects isn't black and white. It often depends on the specific requirements of your application, performance considerations, and the programming environment.

Performance-Intensive Tasks: If your code involves heavy data manipulation, mutable objects might offer better performance due to in-place modifications.
Concurrency & Parallelism: In multi-threaded applications, immutability can be a boon, reducing the complexities of handling shared data.
Data Integrity & Security: For scenarios where data integrity is paramount, such as financial transactions or cryptographic operations, immutability can offer added security.

Understanding the nuances of mutability and immutability is crucial for any developer. It enables informed decisions, ensuring that the code is efficient, robust, and fit for purpose. Before choosing, always weigh the pros and cons in the context of your specific application.

One Pager Cheat Sheet

In software development, the concepts of mutability and immutability, essential to both object-oriented and functional programming, refer to an object's ability to change its internal state, impacting the robustness, efficiency, and clarity of the code.
The article describes the differences between mutable and immutable objects in programming, with mutable objects being changeable after initialization and offering flexibility and memory-efficiency, but issues with thread safety and predictability, and immutable objects being unchangeable after creation providing thread safety, predictability, readability, and security, but can lead to memory overhead; strings are given as an example of immutable objects.
Immutable objects are defined as those whose state cannot be modified after creation, any changes seeming to alter the state actually creates a new object, with the original remaining unchanged, providing benefits in situations that need predictability, readability, thread safety, and security. This trait distinguishes them from mutable objects, which can have their state changed post-creation.
Programmers may prefer mutable objects for their speed & efficiency, convenience and in cases of necessity, like user input or UI modifications, but despite such benefits, mutable objects can lead to higher risk of bugs, making them less suitable except in instances requiring maximum speed or for small simple programs.
The advantages of immutability in programming include improved readability, long-term speed and efficiency, easier traceability, better safety and validity, and ideal caching capabilities due to values of immutable objects being unchangeable without the developer's knowledge.
The image illustrates the concepts of immutability and mutability in programming, with functional programming favoring immutability for reduced bugs and easier reasoning, and imperative programming utilizing mutability for potentially better performance and more natural modeling.
The statement is false as mutability can often result in complex and error-prone code with unexpected side effects, especially in large codebases or among multiple developers, whereas immutability enhances readability and predictability as variables maintain their values, making the code more understandable, manageable, and less prone to bugs.
In Python, mutable data types such as list, dict, set, byte array, and user-defined classes can be modified after their creation, as demonstrated by adding a new favorite movie to a list, while immutable data types like str, int, float, complex, tuple, frozen set, boolean cannot, resulting in a TypeError when trying to change part of a string.
In Java, mutable data types such as Array, ArrayList, HashMap, and java.util.Date allow their values to be changed, while immutable data types like String, Integer, Long, and java.math.BigInteger do not; although some mutable classes can be converted to immutable using methods or libraries like Guava or Apache Commons Lang.
The image provides a comparison between mutable and immutable data types in Python, Java, and JavaScript, highlighting differences such as lists and dictionaries (Python), arrays and hashmaps (Java), and objects and arrays (JavaScript) being mutable, while strings and tuples (Python), strings and primitives (Java), and strings and numbers (JavaScript) are immutable.
In both Java and Python, strings are immutable, meaning they cannot be changed once created, differing from mutable data structures like lists or arrays; this feature enhances security by ensuring string content cannot be altered unintentionally.
In JavaScript, mutable data types like Object and Array can be altered, as demonstrated by changing an element in an array, while immutable data types such as String, Number, Boolean, undefined, and null cannot be changed, which is shown through the failed attempt to modify a string.
In C++, mutable container types include Vector, Map, Set, Deque, Array, and List, which can have their values altered, while immutability is achieved using the const qualifier to prevent any changes to a value.
The distinction between mutability and immutability in programming languages is crucial for developers and should be chosen based on specific needs: mutable objects may improve performance for performance-intensive tasks, immutability can simplify data handling in concurrency and parallelism, and ensure data integrity and security in sensitive operations.

Understanding Mutability & Immutability in Programming

Mutability & Immutability, What’s the Difference?

Mutable Objects: The Malleable Entities

Immutable Objects: The Constants in Chaos

Getting It?

Build your intuition. Is this statement true or false?

Mutability, When and Why Should It?

Immutability, When and Why Should It?

Are you sure you're getting this? Is this statement true or false?

Python

Mutable Data Types

Mutable Example

Immutable Data Types

Immutable Example

Java

Mutable Data Types

Mutable Example

Immutable Data Types

Immutable Example

Build your intuition. Is this statement true or false?

JavaScript

Mutable Data Types

Mutable Example

Immutable Data Types

Immutable Example

C++

Mutable Data Types

Mutable Example

Immutable Data Types

Immutable Example

Conclusion

To Mutate or Not to Mutate?

One Pager Cheat Sheet

Programming Categories

Popular Lessons